chore: remove dead code and improve unknown command errors (#64)

* chore: remove dead code in auth modules

Remove isAuthenticated() from provider.ts and clearCredentials()
from storage.ts — both exported but never imported anywhere.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: improve error message for unknown subcommands

Replace confusing "too many arguments" error with a clear
"Unknown command" message that lists available subcommands.
Covers all levels: top-level, subcommand groups, nested groups,
and commands with a default subcommand.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: sweep stale test buckets in integration test setup

Previous failed/crashed CI runs left behind tigris-cli-test-* buckets
with no cleanup mechanism. Add a best-effort sweeper in beforeAll that
deletes test buckets older than 2 hours.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: reduce stale bucket sweep threshold to 30 minutes

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: use recursive rm for stale bucket sweep

Wildcard `rm t3://bucket/* -f` doesn't match folder markers like
`folder/`, leaving the bucket non-empty and undeletable. Use
`rm t3://bucket -r -f` instead to remove everything including folders.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: use -r -f on bucket contents before deleting bucket

rm -r -f can't be applied directly on a bucket. First recursively
remove all contents (including folder markers) with bucket/*, then
delete the empty bucket.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: pass force flag to removeBucket in delete and rm commands

The force option was not being forwarded to removeBucket, preventing
force-deletion of non-empty buckets.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: only treat implemented commands as known in subcommand check

knownNames included all spec commands regardless of whether they had
implementations. An unimplemented command name would bypass the
"Unknown command" error and silently fall through. Now knownNames
is built from the same implemented-commands filter as the available
list.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: designcode

src/auth/provider.ts

@@ -319,18 +319,6 @@ export async function getStorageConfig(options?: {
   }
 }
 
-/**
- * Check if user is authenticated (either method)
- */
-export async function isAuthenticated(): Promise<boolean> {
-  return (
-    hasAwsProfile() ||
-    getEnvCredentials() !== null ||
-    (await getLoginMethod()) !== null ||
-    getStoredCredentials() !== null
-  );
-}
-
 /**
  * Get storage config with organization overlay from selected org.
  */

src/auth/storage.ts

@@ -391,17 +391,6 @@ export async function storeTemporaryCredentials(
   await writeConfig(config);
 }
 
-/**
- * Clear saved credentials (from configure)
- */
-export async function clearCredentials(): Promise<void> {
-  const config = readConfig();
-  if (config.credentials) {
-    delete config.credentials.saved;
-  }
-  await writeConfig(config);
-}
-
 /**
  * Store the login method used by the user
  */

src/cli-core.ts

@@ -8,6 +8,60 @@ import { Command as CommanderCommand } from 'commander';
 
 import type { Argument, CommandSpec, Specs } from './types.js';
 
+/**
+ * Check if the first positional arg is an unrecognized subcommand.
+ * If so, print a helpful error and exit. Returns the positional args
+ * for the caller to use if no error is found.
+ */
+function checkUnknownSubcommand(
+  actionArgs: unknown[],
+  spec: { commands?: CommandSpec[]; name?: string },
+  currentPath: string[],
+  specs: Specs,
+  hasImplementation: ImplementationChecker
+): string[] {
+  // Commander passes the Command object as the last arg; its .args has positionals
+  const last = actionArgs[actionArgs.length - 1];
+  const positional =
+    typeof last === 'object' && last !== null && 'args' in last
+      ? ((last as { args: string[] }).args as string[])
+      : (actionArgs.filter((a) => typeof a === 'string') as string[]);
+
+  if (positional.length === 0) return positional;
+
+  const first = positional[0];
+  const subcommands = spec.commands ?? [];
+  const implemented = subcommands.filter((c) =>
+    commandHasAnyImplementation(c, [...currentPath, c.name], hasImplementation)
+  );
+  const knownNames = new Set(
+    implemented.flatMap((c) => [
+      c.name,
+      ...(Array.isArray(c.alias) ? c.alias : c.alias ? [c.alias] : []),
+    ])
+  );
+
+  if (!knownNames.has(first)) {
+    const available = implemented.map((c) => c.name);
+    const pathLabel =
+      currentPath.length > 0
+        ? `'${first}' for '${currentPath.join(' ')}'`
+        : `'${first}'`;
+    console.error(`Unknown command ${pathLabel}.`);
+    if (available.length > 0) {
+      console.error(`Available commands: ${available.join(', ')}`);
+    }
+    const helpCmd =
+      currentPath.length > 0
+        ? `${specs.name} ${currentPath.join(' ')} help`
+        : `${specs.name} help`;
+    console.error(`\nRun "${helpCmd}" for usage.`);
+    process.exit(1);
+  }
+
+  return positional;
+}
+
 export interface ModuleLoader {
   (commandPath: string[]): Promise<{
     module: Record<string, unknown> | null;
@@ -458,10 +512,17 @@ export function registerCommands(
             ...(defaultCmd.arguments || []),
           ]);
           addArgumentsToCommand(cmd, allArguments);
+          cmd.allowExcessArguments(true);
 
           cmd.action(async (...args) => {
             const options = args.pop();
-            const positionalArgs = args;
+            const positionalArgs = checkUnknownSubcommand(
+              [options],
+              spec,
+              currentPath,
+              specs,
+              hasImplementation
+            );
 
             if (
               allArguments.length > 0 &&
@@ -486,7 +547,15 @@ export function registerCommands(
           });
         }
       } else {
-        cmd.action(() => {
+        cmd.allowExcessArguments(true);
+        cmd.action((...args) => {
+          checkUnknownSubcommand(
+            args,
+            spec,
+            currentPath,
+            specs,
+            hasImplementation
+          );
           showCommandHelp(specs, spec, currentPath, hasImplementation);
         });
       }
@@ -559,7 +628,15 @@ export function createProgram(config: CLIConfig): CommanderCommand {
       console.log(version);
     });
 
-  program.action(() => {
+  program.allowExcessArguments(true);
+  program.action((...args) => {
+    checkUnknownSubcommand(
+      args,
+      { commands: specs.commands },
+      [],
+      specs,
+      hasImplementation
+    );
     showMainHelp(specs, version, hasImplementation);
   });
 

src/lib/buckets/delete.ts

@@ -44,7 +44,7 @@ export default async function deleteBucket(options: Record<string, unknown>) {
   const deleted: string[] = [];
   const errors: { name: string; error: string }[] = [];
   for (const name of bucketNames) {
-    const { error } = await removeBucket(name, { config });
+    const { error } = await removeBucket(name, { config, force });
 
     if (error) {
       printFailure(context, error.message, { name });

src/lib/rm.ts

@@ -51,7 +51,7 @@ export default async function rm(options: Record<string, unknown>) {
       }
     }
 
-    const { error } = await removeBucket(bucket, { config });
+    const { error } = await removeBucket(bucket, { config, force });
 
     if (error) {
       exitWithError(error);

test/cli.test.ts

@@ -270,6 +270,30 @@ describe.skipIf(skipTests)('CLI Integration Tests', () => {
       console.warn('Failed to setup credentials, tests may fail');
     }
 
+    // Sweep stale test buckets from previous failed runs
+    const staleThresholdMs = 30 * 60 * 1000; // 30 minutes
+    const listResult = runCli('buckets list --format json');
+    if (listResult.exitCode === 0 && listResult.stdout.trim()) {
+      try {
+        const buckets = JSON.parse(listResult.stdout.trim()) as Array<{
+          name: string;
+          created: string;
+        }>;
+        const now = Date.now();
+        for (const bucket of buckets) {
+          if (!bucket.name.startsWith('tigris-cli-test-')) continue;
+          const age = now - new Date(bucket.created).getTime();
+          if (age > staleThresholdMs) {
+            console.log(`Sweeping stale test bucket: ${bucket.name}`);
+            runCli(`rm ${t3(bucket.name)}/* -r -f`);
+            runCli(`rm ${t3(bucket.name)} -f`);
+          }
+        }
+      } catch {
+        // Best-effort cleanup — don't block tests
+      }
+    }
+
     console.log(`Test prefix: ${testPrefix}`);
     console.log(`Creating test bucket: ${testBucket}`);
     // Use mk command instead of buckets create to avoid interactive prompts